home *** CD-ROM | disk | FTP | other *** search
/ Stone Design / Stone Design.iso / Stone_Friends / Wave / WavesWorld / Source / IBPalettes / WWTCLKit / WWThumbWheelCell.m < prev    next >
Encoding:
Text File  |  1995-03-22  |  20.5 KB  |  725 lines
  1.  
  2. #import "WWThumbWheel.h"
  3. #import "WWThumbWheelCell.h"
  4. #import "WWTCLInterp.h"
  5. #import <ctype.h>
  6.  
  7. @implementation WWThumbWheelCell
  8.  
  9.  
  10. + initialize { [WWThumbWheelCell setVersion:5]; return self; }
  11. ////////////////////////////////////////////////////////
  12. //
  13. - init
  14. {
  15.   [super init];
  16.   controlStringSize = 32;
  17.   controlString = (char *)NXZoneCalloc([self zone], controlStringSize, sizeof(char));
  18.   sprintfControlString = (char *)NXZoneCalloc([self zone], controlStringSize, sizeof(char));
  19.   tclExpressionSize = 32;
  20.   tclExpression = (char *)NXZoneCalloc([self zone], tclExpressionSize, sizeof(char));
  21.   tclVarSize = 32;
  22.   tclVar = (char *)NXZoneCalloc([self zone], tclVarSize, sizeof(char));
  23.   tclCommandSize = 32;
  24.   tclCommand = (char *)NXZoneCalloc([self zone], tclCommandSize, sizeof(char));
  25.   tclCommandDirty = YES;
  26.  
  27.   return self;
  28. }
  29. //
  30. - awake
  31. {
  32.   [super awake];
  33.   tclCommandDirty = YES;
  34.   return self;
  35. }
  36.  
  37. - free
  38. {
  39.   if (controlString) { NXZoneFree([self zone], controlString); }
  40.   if (sprintfControlString) { NXZoneFree([self zone], sprintfControlString); }
  41.   if (tclExpression) { NXZoneFree([self zone], tclExpression); }
  42.   if (tclVar) { NXZoneFree([self zone], tclVar); }
  43.   if (tclCommand) { NXZoneFree([self zone], tclCommand); }
  44.   return [super free];
  45. }
  46.  
  47. //
  48. - awakeFromNib
  49. {
  50.   [visibleMinText setFloatValue:[self visibleMin]];
  51.   [visibleMaxText setFloatValue:[self visibleMax]];
  52.   [absoluteMinText setFloatValue:[self absoluteMin]];
  53.   [absoluteMaxText setFloatValue:[self absoluteMax]];
  54.   [valText setFloatValue:[self floatValue]];
  55.   [relativeValText setFloatValue:[self relativeFloatValue]];
  56.   return self;
  57. }
  58. //
  59. - setVisibleMin:(float)value
  60. {
  61.    [visibleMinText setFloatValue:value];
  62.    return [super setVisibleMin:value];
  63. }
  64. //
  65. - setVisibleMax:(float)value
  66. {
  67.    [visibleMaxText setFloatValue:value];
  68.    return [super setVisibleMax:value];
  69. }
  70. //
  71. - setAbsoluteMin:(float)value
  72. {
  73.    [absoluteMinText setFloatValue:value];
  74.    return [super setAbsoluteMin:value];
  75. }
  76. //
  77. - setAbsoluteMax:(float)value
  78. {
  79.    [absoluteMaxText setFloatValue:value];
  80.    return [super setAbsoluteMax:value];
  81. }
  82.  
  83. - setStringValue:(const char *)str
  84. {
  85.   char  *theStr;
  86.  
  87.   [super setStringValue:str];
  88.  
  89.   // boy, this is kind of a hack - this should just work...
  90.   // use super method to avoid redoing the rest...
  91.   [super setFloatValue:(float)atof(str)];
  92.  
  93.   theStr = (char *)[self stringValue];
  94.   [visibleMaxText setStringValue:theStr];
  95.   [visibleMinText setStringValue:theStr];
  96.   [absoluteMaxText setStringValue:theStr];
  97.   [absoluteMinText setStringValue:theStr];
  98.   [valText setStringValue:theStr];
  99.   [relativeValText setStringValue:theStr];
  100.   tclCommandDirty = YES;
  101.   return self;
  102. }
  103.  
  104. - setIntValue:(int)val
  105. {
  106.   int   theVal;
  107.  
  108.  
  109.   [super setIntValue:val];
  110.   theVal = [self intValue];
  111.   [visibleMaxText setIntValue:theVal];
  112.   [visibleMinText setIntValue:theVal];
  113.   [absoluteMaxText setIntValue:theVal];
  114.   [absoluteMinText setIntValue:theVal];
  115.   [valText setIntValue:theVal];
  116.   [relativeValText setIntValue:theVal];
  117.   tclCommandDirty = YES;
  118.   return self;
  119. }
  120.  
  121. - setFloatValue:(float)val
  122. {
  123.   float  theVal;
  124.  
  125.  
  126.   [super setFloatValue:val];
  127.   theVal = [self floatValue];
  128.   [visibleMaxText setFloatValue:theVal];
  129.   [visibleMinText setFloatValue:theVal];
  130.   [absoluteMaxText setFloatValue:theVal];
  131.   [absoluteMinText setFloatValue:theVal];
  132.   [valText setFloatValue:theVal];
  133.   [relativeValText setFloatValue:theVal];
  134.   tclCommandDirty = YES;
  135.   return self;
  136. }
  137.  
  138. - setDoubleValue:(double)val
  139. {
  140.   double  theVal;
  141.  
  142.  
  143.   [super setDoubleValue:val];
  144.   theVal = [self doubleValue];
  145.   [visibleMaxText setDoubleValue:theVal];
  146.   [visibleMinText setDoubleValue:theVal];
  147.   [absoluteMaxText setDoubleValue:theVal];
  148.   [absoluteMinText setDoubleValue:theVal];
  149.   [valText setDoubleValue:theVal];
  150.   [relativeValText setDoubleValue:theVal];
  151.   tclCommandDirty = YES;
  152.   return self;
  153. }
  154.  
  155. - reinitializeControlStringAndTclVarFromZone:(NXZone *)zone
  156. {
  157.   controlString = (char *)NXZoneCalloc(zone, controlStringSize, sizeof(char));
  158.   sprintfControlString = (char *)NXZoneCalloc(zone, controlStringSize, sizeof(char));
  159.   tclExpression = (char *)NXZoneCalloc(zone, tclExpressionSize, sizeof(char));
  160.   tclVar = (char *)NXZoneCalloc(zone, tclVarSize, sizeof(char));
  161.   tclCommand = (char *)NXZoneCalloc(zone, tclCommandSize, sizeof(char));
  162.   return self;
  163. }
  164.  
  165. - copyFromZone:(NXZone *)zone
  166. {
  167.   id newCopy = [super copyFromZone:zone];
  168.  
  169.  
  170.   [newCopy reinitializeControlStringAndTclVarFromZone:zone];
  171.   [newCopy setControlString:controlString];
  172.   [newCopy setTclExpression:tclExpression];
  173.   [newCopy setTclVar:tclVar];
  174.   [newCopy setTclCommand:tclCommand];
  175.  
  176.   return newCopy;
  177. }
  178.  
  179. - setInterp:newInterp {  interp = newInterp; return self; }
  180. - interp { return interp; }
  181.  
  182. - resizeTclCommandForArgVector:(char *)argOrderVector
  183. {
  184.   BOOL    done = NO;
  185.  
  186.  
  187.   if (!done && !strcmp("d", argOrderVector))
  188.   {  while (tclCommandSize < (controlStringSize + 32))
  189.      {  if (!tclCommandSize)
  190.     {  tclCommandSize = 32;
  191.            tclCommand = (char *)NXZoneCalloc([self zone], tclCommandSize, sizeof(char));
  192.         }
  193.         else
  194.         {  tclCommandSize *= 2;
  195.            tclCommand = (char *)NXZoneRealloc([self zone], tclCommand, tclCommandSize);
  196.         }
  197.      }
  198.      done = YES;
  199.   }
  200.   if (!done && !strcmp("f", argOrderVector))
  201.   {  while (tclCommandSize < (controlStringSize + 32) )
  202.      {  if (!tclCommandSize)
  203.     {  tclCommandSize = 32;
  204.            tclCommand = (char *)NXZoneCalloc([self zone], tclCommandSize, sizeof(char));
  205.         }
  206.         else
  207.         {  tclCommandSize *= 2;
  208.            tclCommand = (char *)NXZoneRealloc([self zone], tclCommand, tclCommandSize);
  209.         }
  210.      }
  211.      done = YES;
  212.   }
  213.   if (!done && !strcmp("fff", argOrderVector))
  214.   {  while (tclCommandSize  < (controlStringSize + (2 + (3 * 32))))
  215.      {  if (!tclCommandSize)
  216.     {  tclCommandSize = 32;
  217.            tclCommand = (char *)NXZoneCalloc([self zone], tclCommandSize, sizeof(char));
  218.         }
  219.         else
  220.         {  tclCommandSize *= 2;
  221.            tclCommand = (char *)NXZoneRealloc([self zone], tclCommand, tclCommandSize);
  222.         }
  223.      }
  224.      done = YES;
  225.   }
  226.  
  227.   if (!done && !strcmp("RGB", argOrderVector))
  228.   {  while (tclCommandSize  < (controlStringSize + (2 + (3 * 32))))
  229.      {  if (!tclCommandSize)
  230.     {  tclCommandSize = 32;
  231.            tclCommand = (char *)NXZoneCalloc([self zone], tclCommandSize, sizeof(char));
  232.         }
  233.         else
  234.         {  tclCommandSize *= 2;
  235.            tclCommand = (char *)NXZoneRealloc([self zone], tclCommand, tclCommandSize);
  236.         }
  237.      }
  238.      done = YES;
  239.   }
  240.  
  241.   if (!done && !strcmp("s", argOrderVector))
  242.   {  const char  *str = [self stringValue]; 
  243.      int   strLen = strlen(str);
  244.  
  245.      while (tclCommandSize < (controlStringSize + strLen))
  246.      {  if (!tclCommandSize)
  247.     {  tclCommandSize = 32;
  248.            tclCommand = (char *)NXZoneCalloc([self zone], tclCommandSize, sizeof(char));
  249.         }
  250.         else
  251.         {  tclCommandSize *= 2;
  252.            tclCommand = (char *)NXZoneRealloc([self zone], tclCommand, tclCommandSize);
  253.         }
  254.      }
  255.      done = YES;
  256.   }
  257.   // those were the easy ones; now for the permutations...
  258.  
  259.   return self;
  260. }
  261.  
  262.  
  263. - updateTclCommand
  264. {
  265.   char    *controlStringPtr, *sprintfControlStringPtr;
  266.   BOOL    done;
  267.   int     argOrderSize = 32;
  268.   char    *argOrderVector = (char *)NXZoneCalloc([self zone], argOrderSize, sizeof(char));
  269.   int     argOrderOffset = 0;
  270.  
  271.  
  272.   if (!controlString)
  273.   {  return nil;
  274.   }
  275.  
  276.   // we want to grovel over the controlString, 
  277.   // for right now, we really only tend to have the following patterns 
  278.   // in the controlString: 1 %f, 1 %d, 1 %s, %R, %G, %B
  279.   controlStringPtr = controlString;
  280.   sprintfControlStringPtr = sprintfControlString;
  281.   strcpy(sprintfControlString, controlString);
  282.   while (*controlStringPtr)
  283.   {  if (*controlStringPtr == '%')
  284.      {  sprintfControlStringPtr++;  controlStringPtr++;
  285.         if (*controlStringPtr)
  286.         {  switch (*controlStringPtr)
  287.            {  case 'd':    while (argOrderOffset >= argOrderSize)
  288.                         {  argOrderSize *= 2;
  289.                            argOrderVector = (char *)NXZoneRealloc([self zone], argOrderVector, argOrderSize);
  290.                         }
  291.                         argOrderVector[argOrderOffset++] = 'd';
  292.                         sprintfControlStringPtr++; controlStringPtr++;
  293.             break;
  294.               case 'f':    while (argOrderOffset >= argOrderSize)
  295.                         {  argOrderSize *= 2;
  296.                            argOrderVector = (char *)NXZoneRealloc([self zone], argOrderVector, argOrderSize);
  297.                         }
  298.                         argOrderVector[argOrderOffset++] = 'f';
  299.                         sprintfControlStringPtr++; controlStringPtr++;
  300.             break;
  301.               case 's':    while (argOrderOffset >= argOrderSize)
  302.                         {  argOrderSize *= 2;
  303.                            argOrderVector = (char *)NXZoneRealloc([self zone], argOrderVector, argOrderSize);
  304.                         }
  305.                         argOrderVector[argOrderOffset++] = 's';
  306.                         sprintfControlStringPtr++; controlStringPtr++;
  307.             break;
  308.               case 'R':    while (argOrderOffset >= argOrderSize)
  309.                         {  argOrderSize *= 2;
  310.                            argOrderVector = (char *)NXZoneRealloc([self zone], argOrderVector, argOrderSize);
  311.                         }
  312.                         argOrderVector[argOrderOffset++] = 'R';
  313.                         *sprintfControlStringPtr++ = 'f'; controlStringPtr++;
  314.                         break;
  315.               case 'G':    while (argOrderOffset >= argOrderSize)
  316.                         {  argOrderSize *= 2;
  317.                            argOrderVector = (char *)NXZoneRealloc([self zone], argOrderVector, argOrderSize);
  318.                         }
  319.                         argOrderVector[argOrderOffset++] = 'G';
  320.                         *sprintfControlStringPtr++ = 'f'; controlStringPtr++;
  321.                         break;
  322.               case 'B':    while (argOrderOffset >= argOrderSize)
  323.                         {  argOrderSize *= 2;
  324.                            argOrderVector = (char *)NXZoneRealloc([self zone], argOrderVector, argOrderSize);
  325.                         }
  326.                         argOrderVector[argOrderOffset++] = 'B'; *sprintfControlStringPtr++ = 'f';
  327.                         controlStringPtr++;
  328.                         break;
  329.               case '%':    sprintfControlStringPtr++; controlStringPtr++;
  330.                         break;
  331.                default:    NXLogError("WWSliderCell: unknown specifier <%c> in controlString.\n", *controlStringPtr);
  332.                         sprintfControlStringPtr++; controlStringPtr++;
  333.             break;
  334.            }
  335.        }
  336.      }
  337.      else
  338.      {  sprintfControlStringPtr++;  controlStringPtr++;
  339.      }
  340.   }
  341.   argOrderVector[argOrderOffset] = 0;
  342.  
  343.   done = NO;
  344.  
  345.   if (!done && !strcmp("d", argOrderVector))
  346.   {  [self resizeTclCommandForArgVector:argOrderVector];
  347.      sprintf(tclCommand, sprintfControlString, [self intValue]);
  348.      done = YES;
  349.   }
  350.   if (!done && !strcmp("f", argOrderVector))
  351.   {  [self resizeTclCommandForArgVector:argOrderVector];
  352.      sprintf(tclCommand, sprintfControlString, [self floatValue]);
  353.      done = YES;
  354.   }
  355.   if (!done && !strcmp("s", argOrderVector))
  356.   {  [self resizeTclCommandForArgVector:argOrderVector];
  357.      sprintf(tclCommand, sprintfControlString, [self stringValue]);
  358.      done = YES;
  359.   }
  360.   // for back compatibility
  361.   if (!done && !strcmp("fff", argOrderVector))
  362.   {  [self resizeTclCommandForArgVector:argOrderVector];
  363.      sprintf(tclCommand, sprintfControlString, NXRedComponent(color), NXGreenComponent(color), NXBlueComponent(color));
  364.      done = YES;
  365.   }
  366.   if (!done && !strcmp("RGB", argOrderVector))
  367.   {  [self resizeTclCommandForArgVector:argOrderVector];
  368.      sprintf(tclCommand, sprintfControlString, NXRedComponent(color), NXGreenComponent(color), NXBlueComponent(color));
  369.      done = YES;
  370.   }
  371.   if (!done && !strcmp("fRGB", argOrderVector))
  372.   {  [self resizeTclCommandForArgVector:argOrderVector];
  373.      sprintf(tclCommand, sprintfControlString, [self floatValue], NXRedComponent(color), NXGreenComponent(color), NXBlueComponent(color));
  374.      done = YES;
  375.   }
  376.   if (!done && !strcmp("RGBf", argOrderVector))
  377.   {  [self resizeTclCommandForArgVector:argOrderVector];
  378.      sprintf(tclCommand, sprintfControlString, NXRedComponent(color), NXGreenComponent(color), NXBlueComponent(color), [self floatValue]);
  379.      done = YES;
  380.   }
  381.   if (!done && !strcmp("dRGB", argOrderVector))
  382.   {  [self resizeTclCommandForArgVector:argOrderVector];
  383.      sprintf(tclCommand, sprintfControlString, [self intValue], NXRedComponent(color), NXGreenComponent(color), NXBlueComponent(color));
  384.      done = YES;
  385.   }
  386.   if (!done && !strcmp("RGBd", argOrderVector))
  387.   {  [self resizeTclCommandForArgVector:argOrderVector];
  388.      sprintf(tclCommand, sprintfControlString, NXRedComponent(color), NXGreenComponent(color), NXBlueComponent(color), [self intValue]);
  389.      done = YES;
  390.   }
  391.  
  392.   if (!done)
  393.   {  while (tclCommandSize < controlStringSize)
  394.      {  if (!tclCommandSize)
  395.     {  tclCommandSize = 32;
  396.            tclCommand = (char *)NXZoneCalloc([self zone], tclCommandSize, sizeof(char));
  397.         }
  398.         else
  399.         {  tclCommandSize *= 2;
  400.            tclCommand = (char *)NXZoneRealloc([self zone], tclCommand, tclCommandSize);
  401.         }
  402.      }
  403.      strcpy(tclCommand, controlString);
  404.   }
  405.   tclCommandDirty = NO;
  406.  
  407.   NXZoneFree([self zone], argOrderVector);
  408.  
  409.   return self;
  410. }
  411.  
  412.  
  413. - evaluateSelf
  414. {
  415.    int   ret;
  416.    char  *newStringValue;
  417.    id    retID;
  418.  
  419.  
  420.   newStringValue = [interp globalEval:tclExpression :&ret];
  421.   if ((ret == TCL_OK) || (ret == TCL_RETURN))
  422.   {  [self setStringValue:newStringValue];
  423.      retID = self;
  424.   }
  425.   else
  426.   {  NXLogError("WWSliderCell: error <%s> evaluating tcl expression <%s>\n", 
  427.         newStringValue, tclExpression);
  428.      if (newStringValue) { free(newStringValue); }
  429.      retID = nil;
  430.   }
  431.   return retID;
  432. }
  433.  
  434. - updateInterp
  435. {
  436.   if ([interp eval:[self tclCommand]])
  437.   {  return self;
  438.   }
  439.   return nil;
  440. }
  441.  
  442.  
  443. - setControlString:(const char *)str 
  444. { 
  445.   int   cnt;
  446.  
  447.  
  448.   if (!str) { return self; }
  449.   if (controlStringSize <= 0) 
  450.   {  controlStringSize = 32; 
  451.      controlString = (char *)NXZoneCalloc([self zone], controlStringSize, sizeof(char));
  452.   }
  453.   cnt = strlen(str);
  454.   while (cnt >= controlStringSize)
  455.   {  controlStringSize *= 2;
  456.      controlString = (char *)NXZoneRealloc([self zone], controlString, controlStringSize);
  457.   }
  458.   if (sprintfControlString)
  459.   {  sprintfControlString = (char *)NXZoneRealloc([self zone], sprintfControlString, controlStringSize);
  460.   }
  461.   else
  462.   {  sprintfControlString = (char *)NXZoneCalloc([self zone], controlStringSize, sizeof(char));
  463.   }
  464.   strcpy(controlString, str); 
  465.   tclCommandDirty = YES;
  466.   return self; 
  467. }
  468. //
  469. - (const char *)controlString { return controlString; }
  470.  
  471. - setTclExpression:(const char *)str 
  472. { 
  473.   int   cnt;
  474.  
  475.  
  476.   if (!str) { return self; }
  477.   if (tclExpressionSize <= 0) 
  478.   {  tclExpressionSize = 32; 
  479.      tclExpression = (char *)NXZoneCalloc([self zone], tclExpressionSize, sizeof(char));
  480.   }
  481.   cnt = strlen(str);
  482.   while (cnt >= tclExpressionSize)
  483.   {  tclExpressionSize *= 2;
  484.      tclExpression = (char *)NXZoneRealloc([self zone], tclExpression, tclExpressionSize);
  485.   }
  486.   strcpy(tclExpression, str); 
  487.   return self; 
  488. }
  489. //
  490. - (const char *)tclExpression { return tclExpression; }
  491.  
  492. - setTclVar:(const char *)str 
  493. { 
  494.   int   cnt;
  495.  
  496.  
  497.   if (!str) { return self; }
  498.   if (tclVarSize <= 0) 
  499.   {  tclVarSize = 32; 
  500.      tclVar = (char *)NXZoneCalloc([self zone], tclVarSize, sizeof(char));
  501.   }
  502.   cnt = strlen(str);
  503.   while (cnt >= tclVarSize)
  504.   {  tclVarSize *= 2;
  505.      tclVar = (char *)NXZoneRealloc([self zone], tclVar, tclVarSize);
  506.   }
  507.   strcpy(tclVar, str); 
  508.   return self; 
  509. }
  510. //
  511. - (const char *)tclVar { return tclVar; }
  512.  
  513. - setTclCommand:(const char *)str 
  514. { 
  515.   int   cnt;
  516.  
  517.  
  518.   if (!str) { return self; }
  519.   if (tclCommandSize <= 0) 
  520.   {  tclCommandSize = 32; 
  521.      tclCommand = (char *)NXZoneCalloc([self zone], tclCommandSize, sizeof(char));
  522.   }
  523.   cnt = strlen(str);
  524.   while (cnt >= tclCommandSize)
  525.   {  tclCommandSize *= 2;
  526.      tclCommand = (char *)NXZoneRealloc([self zone], tclCommand, tclCommandSize);
  527.   }
  528.   strcpy(tclCommand, str); 
  529.   return self; 
  530. }
  531. //
  532. - (const char *)tclCommand 
  533. { 
  534.   if (tclCommandDirty)
  535.   {  [self updateTclCommand];
  536.   }
  537.   return tclCommand; 
  538. }
  539.  
  540.  
  541. - write:(NXTypedStream *)stream 
  542. {
  543.    [super write:stream];
  544.    NXWriteType(stream, "*", &controlString);
  545.    NXWriteType(stream, "*", &tclVar);
  546.    NXWriteType(stream, "*", &tclExpression);
  547.    NXWriteType(stream, "*", &tclCommand);
  548.    NXWriteObjectReference(stream, interp);
  549.    return self;
  550. }
  551. //
  552. - read:(NXTypedStream *)stream 
  553. {
  554.    int version;
  555.  
  556.    [super read:stream];
  557.  
  558.    version = NXTypedStreamClassVersion(stream, "WWThumbWheelCell");
  559.    if (version == 1)
  560.    {  NXReadType(stream, "*", &controlString);
  561.       if (controlString) 
  562.       {  controlStringSize = strlen(controlString) + 1;
  563.          sprintfControlString = (char *)NXZoneCalloc([self zone], controlStringSize, sizeof(char));
  564.       }
  565.       else
  566.       {  controlStringSize = 0;
  567.          sprintfControlString = NULL;
  568.       }
  569.       NXReadType(stream, "*", &tclVar);
  570.       if (tclVar) 
  571.       {  tclVarSize = strlen(tclVar) + 1;
  572.       }
  573.       else
  574.       { tclVarSize = 0;
  575.       }
  576.       tclCommandSize = 0;
  577.       tclCommand = NULL;
  578.    }
  579.    if (version == 2)
  580.    {  NXReadType(stream, "*", &controlString);
  581.       if (controlString) 
  582.       {  controlStringSize = strlen(controlString) + 1;
  583.          sprintfControlString = (char *)NXZoneCalloc([self zone], controlStringSize, sizeof(char));
  584.       }
  585.       else
  586.       {  controlStringSize = 0;
  587.          sprintfControlString = NULL;
  588.       }
  589.       NXReadType(stream, "*", &tclVar);
  590.       if (tclVar) 
  591.       {  tclVarSize = strlen(tclVar) + 1;
  592.       }
  593.       else
  594.       { tclVarSize = 0;
  595.       }
  596.       NXReadType(stream, "*", &tclExpression);
  597.       if (tclExpression) 
  598.       {  tclExpressionSize = strlen(tclExpression) + 1;
  599.       }
  600.       else
  601.       {  tclExpressionSize = 0;
  602.       }
  603.       tclCommandSize = 0;
  604.       tclCommand = NULL;
  605.    }
  606.    if (version == 3)
  607.    {  NXReadType(stream, "*", &controlString);
  608.       if (controlString) 
  609.       {  controlStringSize = strlen(controlString) + 1;
  610.       }
  611.       else
  612.       {  controlStringSize = 0;
  613.       }
  614.       NXReadType(stream, "*", &tclVar);
  615.       if (tclVar) 
  616.       {  tclVarSize = strlen(tclVar) + 1;
  617.       }
  618.       else
  619.       { tclVarSize = 0;
  620.       }
  621.       NXReadType(stream, "*", &tclExpression);
  622.       if (tclExpression) 
  623.       {  tclExpressionSize = strlen(tclExpression) + 1;
  624.       }
  625.       else
  626.       {  tclExpressionSize = 0;
  627.       }
  628.       NXReadType(stream, "*", &tclCommand);
  629.       if (tclCommand) 
  630.       {  tclCommandSize = strlen(tclCommand) + 1;
  631.       }
  632.       else
  633.       { tclCommandSize = 0;
  634.       }
  635.       NXReadType(stream, "*", &sprintfControlString);
  636.    }
  637.    if (version == 4)
  638.    {  NXReadType(stream, "*", &controlString);
  639.       if (controlString) 
  640.       {  controlStringSize = strlen(controlString) + 1;
  641.       }
  642.       else
  643.       {  controlStringSize = 0;
  644.       }
  645.       NXReadType(stream, "*", &tclVar);
  646.       if (tclVar) 
  647.       {  tclVarSize = strlen(tclVar) + 1;
  648.       }
  649.       else
  650.       { tclVarSize = 0;
  651.       }
  652.       NXReadType(stream, "*", &tclExpression);
  653.       if (tclExpression) 
  654.       {  tclExpressionSize = strlen(tclExpression) + 1;
  655.       }
  656.       else
  657.       {  tclExpressionSize = 0;
  658.       }
  659.       NXReadType(stream, "*", &tclCommand);
  660.       if (tclCommand) 
  661.       {  tclCommandSize = strlen(tclCommand) + 1;
  662.       }
  663.       else
  664.       { tclCommandSize = 0;
  665.       }
  666.       NXReadType(stream, "*", &sprintfControlString);
  667.       interp = NXReadObject(stream);
  668.       if (sprintfControlString) {  free(sprintfControlString); }
  669.       if (controlStringSize)
  670.       {  sprintfControlString = (char *)NXZoneCalloc([self zone], controlStringSize, sizeof(char));
  671.       }
  672.       else
  673.       {  sprintfControlString = NULL;
  674.       }
  675.    }
  676.    if (version == 5)
  677.    {  NXReadType(stream, "*", &controlString);
  678.       if (controlString) 
  679.       {  controlStringSize = strlen(controlString) + 1;
  680.          sprintfControlString = (char *)NXZoneCalloc([self zone], controlStringSize, sizeof(char));
  681.       }
  682.       else
  683.       {  controlStringSize = 0;
  684.          sprintfControlString = NULL;
  685.       }
  686.       NXReadType(stream, "*", &tclVar);
  687.       if (tclVar) 
  688.       {  tclVarSize = strlen(tclVar) + 1;
  689.       }
  690.       else
  691.       { tclVarSize = 0;
  692.       }
  693.       NXReadType(stream, "*", &tclExpression);
  694.       if (tclExpression) 
  695.       {  tclExpressionSize = strlen(tclExpression) + 1;
  696.       }
  697.       else
  698.       {  tclExpressionSize = 0;
  699.       }
  700.       NXReadType(stream, "*", &tclCommand);
  701.       if (tclCommand) 
  702.       {  tclCommandSize = strlen(tclCommand) + 1;
  703.       }
  704.       else
  705.       { tclCommandSize = 0;
  706.       }
  707.       interp = NXReadObject(stream);
  708.    }
  709.    return self;
  710. }
  711.  
  712. // IB stuff
  713. - (const char *)getInspectorClassName 
  714. {  
  715.    NXEvent  *event = [NXApp currentEvent];
  716.  
  717.    if (event->flags & NX_ALTERNATEMASK)
  718.    {  return [super getInspectorClassName];
  719.    }
  720.    
  721.    return "WWThumbWheelCellIBInspector"; 
  722. }
  723.  
  724. @end
  725.